import config from "@/config";

class commonFun {

  /**
   * @desc 分享
   * page 分享路径 默认当前路径
   * params 分享参数 {}
   * imageUrl 图片路径 自定义图片路径，可以是本地文件路径、代码包文件路径或者网络图片路径。支持PNG及JPG。显示图片长宽比是 5:4。
   * title 分享标题 ’‘ 默认 标题
   * selfFun onShareAppMessage本身传过来的值
   * */
  shareAppMessage(options) {
    //当前路径
    let pages = getCurrentPages();
    let cp = pages[pages.length - 1].__route__;
    let $path = options.page ? options.page : cp;
    if (options.params) {
      let str = '';
      for (let i in options.params) {
        str += `&${i}=${options.params[i]}`;
      }
      $path += '?' + str.substr(1);
    }
    console.log($path, '我是分享出去的链接')
    if (options.selfFun) {
      const selfFun = options.selfFun;
      if (selfFun.from === 'button') {
        // 来自页面内转发按钮
        console.log('来自页面内转发按钮==', selfFun.target)
      }
    }
    let shareData = {
      title: options.title || config.title,
      imageUrl: options.imageUrl || null,
      path: $path
    };
    console.log(shareData, '我是分享出去的配置')
    return shareData
  }

  //设置底部tab红点
  setDot(obj) {
    uni.showTabBarRedDot({
      index: obj.index,
      success: function () {
        console.log("设置红点成功")
      }
    });
    uni.setTabBarBadge({
      index: obj.index,
      text: obj.text
    })
  }

  // 移除tab红点
  removeDot(index) {
    uni.removeTabBarBadge({
      index: index
    });
    uni.hideTabBarRedDot({
      index: index
    })
  }

  // 测试头部导航标题
  setNavigationBarTitle(title) {
    uni.setNavigationBarTitle({
      title: title
    })
  }

  // 显示头部导航loading
  showNavigationBarLoading($isTitle) {
    uni.showNavigationBarLoading();
    if ($isTitle) {
      this.setNavigationBarTitle('正在加载中')
    }
  }

  // 隐藏头部导航loading
  hideNavigationBarLoading(isTitle) {
    uni.hideNavigationBarLoading();
    if (isTitle) {
      this.setNavigationBarTitle('');
    }
    uni.stopPullDownRefresh();
  }

  //显示 loading 提示框
  showLoading(title = '加载中...') {
    uni.showLoading({
      title: title,
      mask: true
    })
  }

  //hide loading 提示框
  hideLoading() {
    uni.hideLoading();
    uni.stopPullDownRefresh();
  }

  // 消息提示框
  showToast(title = '即将开放', icon = 'none', duration = 2000) {
    uni.showToast({
      icon,
      duration,
      title
    });
  }


  //显示模态对话框
  showModal(obj) {
    uni.showModal({
      title: obj && obj.title || '温馨提示',
      showCancel: obj && obj.showCancel,
      cancelColor: obj && obj.cancelColor || '#000',
      cancelText: obj && obj.cancelText || '取消',
      confirmColor: obj && obj.confirmColor || '#3cc51f',
      confirmText: obj && obj.confirmText || '确定',
      content: obj && obj.content || '',
      success(res) {
        if (res.confirm) {
          obj && obj.confirm && obj.confirm();
        } else if (res.cancel) {
          obj && obj.cancel && obj.cancel();
        }
      }
    })
  }

  //返回
  back(num = 1) {
    uni.navigateBack({
      delta: num
    });
  }

  /**
   * page -> config 声明的页面名称 或者完整路径，都可以
   * params 页面的参数 => Object -> pageType:跳转类型(navigateTo,redirectTo,reLaunch,switchTab)   其他key是正常参数
   * */
  goto(page, params) {
    let url = page.indexOf('/') > -1 ? page : config.page[page];
    if (!url) {
      this.goto('errorPage', {
        pageType: 'reLaunch',
        title: '哎呀，这个页面跑了哦',
        icon: 'iconicon-test',
      });
      return false;
    }
    let pageType = 'navigateTo';
    if (params) {
      let str = '';
      for (let i in params) {
        // console.log(i);
        if (i === 'pageType') {
          pageType = params[i];
        } else {
          str += `&${i}=${params[i]}`;
        }
      }
      if (str) {
        url += '?' + str.substr(1);
      }
    }
    // console.log(url, pageType);
    wx[pageType]({
      url
    });
  }

  /**
   * $allImgAttr 要查看的图片数组
   * $index 图片索引
   * */
  previewImage($allImgAttr, $index) {
    uni.previewImage({
      current: $allImgAttr[$index] || 0,
      urls: $allImgAttr
    })
  }

  /**
   * @description 读取本地存储，
   * @todo 读取本地存储，判断key只能是string且非纯空格 如果不是将报错
   * @param options
   */
  getStorage(options) {
    let key = options.key;
    if (typeof key != "string") {
      throw new Error("key is typeof string at commonFun.getStorage");
      return false;
    }

    if (key.trim() === "") {
      throw new Error("key is not null at commonFun.getStorage");
      return false;
    }
    return new Promise((resolve, reject) => {
      uni.getStorage({
        key: key.trim(),
        success: function ($data) {
          resolve(res);
        },
        fail: function ($data) {
          reject($data);
        },
      })
    })
  }

  /**
   * @description 设置本地存储，
   * @todo 设置本地存储，判断key只能是string且非纯空格 如果不是将报错，
   * @param options
   */
  async setStorage(options) {

    let key = options.key;
    let data = options.data;
    // console.log(options)
    if (typeof key != "string") {
      throw new Error("key is typeof string at commonFun.setStorage");
      return false;
    }

    if (key.trim() === "") {
      throw new Error("key is not null at commonFun.setStorage");
      return false;
    }
    return new Promise((resolve, reject) => {
      uni.setStorage({
        key: key.trim(),
        data,
        success: function (res) {
          resolve(res);
        },
        fail: function (res) {
          reject(res);
        },
      })
    });
  }

  /**
   * @description 清理本地存储，
   * @todo 清理本地存储，如果key为空则清空所有，如果key不为空则清空指定的key
   * @param options
   */
  async rmStorage(options) {
    let key = options.key;
    if (typeof key != "string") {
      throw new Error("key is typeof string at commonFun.rmStorage");
      return false;
    }
    uni.removeStorage({
      key: key.trim(),
      success(res) {
        if (options.success) options.success(res);
      },
      fail(e) {
        if (options.fail) options.fail(e);
      }
    })
  }

  // 可以通过 uni.getSetting 先查询一下用户是否授权了 有平台差异
  //例子：pagesIndex/goodsDetail/goodsDetail
  authSetting(str) {
    return new Promise((resolve, reject) => {
      uni.getSetting({
        success(res) {
          if (!Object.keys(res.authSetting).length || !(str in res.authSetting) || res.authSetting[str]) {
            resolve(true)
          } else {
            resolve(false)
          }
        }, fail(e) {
          reject(e);
        }
      })
    })
  }

  /**
   * @param fn {Function}   实际要执行的函数
   * @param delay {Number}  延迟时间，也就是阈值，单位是毫秒（ms）
   * @return {Function}     返回一个“去弹跳”了的函数
   */
  // 去抖动函数 (使用场景，输入框连续输入的时候，延迟最后才执行一次)
  debounce(fn, delay) {
    // 定时器，用来 setTimeout
    let timer;
    delay || (delay = 100);
    // 返回一个函数，这个函数会在一个时间区间结束后的 delay 毫秒时执行 fn 函数
    return function () {
      // 保存函数调用时的上下文和参数，传递给 fn
      let context = this;
      let args = arguments;
      // 每次这个返回的函数被调用，就清除定时器，以保证不执行 fn
      clearTimeout(timer);
      // 当返回的函数被最后一次调用后（也就是用户停止了某个连续的操作），
      // 再过 delay 毫秒就执行 fn
      timer = setTimeout(function () {
        fn.apply(context, args);
      }, delay);
    }
  }

  /**
   * @param fn {Function}   实际要执行的函数
   * @param delay {Number}  执行间隔，单位是毫秒（ms）
   * @return {Function}     返回一个“节流”函数
   */
  // 节流阀函数 (节流就是提交表单的时候  用户连续点击了5次  但是我们规定N秒之内 只会提交一次)
  throttle(fn, threshhold) {
    let last; // 记录上次执行的时间
    let timer; // 定时器
    threshhold || (threshhold = 500); // 默认间隔为 500ms

    return function () { // 返回的函数，每过 threshhold 毫秒就执行一次 fn 函数
      // 保存函数调用时的上下文和参数，传递给 fn
      let context = this
      let args = arguments;
      let now = +new Date();

      // 如果距离上次执行 fn 函数的时间小于 threshhold，那么就放弃
      // 执行 fn，并重新计时
      if (last && now < last + threshhold) {
        // clearTimeout(timer)
        // // 保证在当前时间区间结束后，再执行一次 fn
        // timer = setTimeout(function () {
        //   last = now
        //   fn.apply(context, args)
        // }, threshhold)

        // 在时间区间的最开始和到达指定间隔的时候执行一次 fn
      } else {
        last = now;
        fn.apply(context, args);
      }
    }
  }

  //倒计时函数
  repeat(time, callbcak) {
    let that = this;
    if (time > 0) {
      callbcak(time);
      time--;
      setTimeout(function () {
        that.repeat(time, callbcak);
      }, 1000);
    } else {
      callbcak(0);
    }
  }

  /** 判断是否为json格式*/
  isJson(str) {
    if (typeof str === 'string') {
      try {
        let obj = JSON.parse(str);
        return !!(typeof obj === 'object' && obj);
      } catch (e) {
        return false;
      }
    }
  }

  /** 获取dataset
   *  $isDetail 是否也需要返回detail
   * */
  getDataSet(ev, $isDetail = false) {
    if (!ev) return {};
    if ($isDetail) {
      return {
        dataset: ev.currentTarget.dataset,
        detail: ev.detail,
      }
    }
    return ev.currentTarget.dataset;
  }
}

/**
 * @public
 * @description 为string新增方法，trim为string去掉两端空格
 */
String.prototype.trim = function () {
  return this.replace(/(^\s*)|(\s*$)/g, "");
};


module.exports = new commonFun;
uni.$Fun = new commonFun();